YES(O(1),O(n^3)) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict Trs: { *(@x, @y) -> #mult(@x, @y) , +(@x, @y) -> #add(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult(@t, @acc) -> bftMult'(tuple#2(::(@t, nil()), nil()), @acc) , bftMult'(@queue, @acc) -> bftMult'#1(bftMult'#2(@queue), @acc) , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , bftMult'#1(tuple#2(@elem, @queue), @acc) -> bftMult'#3(@elem, @acc, @queue) , bftMult'#3(::(@t, @_@3), @acc, @queue) -> bftMult'#4(@t, @acc, @queue) , bftMult'#3(nil(), @acc, @queue) -> @acc , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , bftMult'#4(leaf(), @acc, @queue) -> bftMult'(@queue, @acc) , bftMult'#4(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , bftMult'#5(@queue', @acc, @y) -> bftMult'(@queue', matrixMult(@acc, @y)) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() } Weak Trs: { #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We add following dependency tuples: Strict DPs: { *^#(@x, @y) -> c_1(#mult^#(@x, @y)) , +^#(@x, @y) -> c_2(#add^#(@x, @y)) , appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) , appendreverse#1^#(nil(), @sofar) -> c_5() , bftMult^#(@t, @acc) -> c_6(bftMult'^#(tuple#2(::(@t, nil()), nil()), @acc)) , bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#3^#(nil(), @acc, @queue) -> c_11() , bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , dequeue#1^#(::(@t, @ts), @inq) -> c_24() , dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) , enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() , matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , matrixMult#1^#(nil(), @m2) -> c_35() , computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#1^#(nil(), @acc, @m) -> c_20() , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() , lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#1^#(nil(), @l2, @n) -> c_31() , dequeue#2^#(::(@t, @ts)) -> c_27() , dequeue#2^#(nil()) -> c_28() , reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) } Weak DPs: { #mult^#(#0(), #0()) -> c_36() , #mult^#(#0(), #neg(@y)) -> c_37() , #mult^#(#0(), #pos(@y)) -> c_38() , #mult^#(#neg(@x), #0()) -> c_39() , #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_42() , #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_45() , #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_58() , #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_50() , #pred^#(#neg(#s(@x))) -> c_51() , #pred^#(#pos(#s(#0()))) -> c_52() , #pred^#(#pos(#s(#s(@x)))) -> c_53() , #succ^#(#0()) -> c_54() , #succ^#(#neg(#s(#0()))) -> c_55() , #succ^#(#neg(#s(#s(@x)))) -> c_56() , #succ^#(#pos(#s(@x))) -> c_57() , #natadd^#(#0(), @y) -> c_60() , #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) } and mark the set of starting terms. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { *^#(@x, @y) -> c_1(#mult^#(@x, @y)) , +^#(@x, @y) -> c_2(#add^#(@x, @y)) , appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) , appendreverse#1^#(nil(), @sofar) -> c_5() , bftMult^#(@t, @acc) -> c_6(bftMult'^#(tuple#2(::(@t, nil()), nil()), @acc)) , bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#3^#(nil(), @acc, @queue) -> c_11() , bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , dequeue#1^#(::(@t, @ts), @inq) -> c_24() , dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) , enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() , matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , matrixMult#1^#(nil(), @m2) -> c_35() , computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#1^#(nil(), @acc, @m) -> c_20() , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() , lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#1^#(nil(), @l2, @n) -> c_31() , dequeue#2^#(::(@t, @ts)) -> c_27() , dequeue#2^#(nil()) -> c_28() , reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) } Weak DPs: { #mult^#(#0(), #0()) -> c_36() , #mult^#(#0(), #neg(@y)) -> c_37() , #mult^#(#0(), #pos(@y)) -> c_38() , #mult^#(#neg(@x), #0()) -> c_39() , #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_42() , #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_45() , #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_58() , #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_50() , #pred^#(#neg(#s(@x))) -> c_51() , #pred^#(#pos(#s(#0()))) -> c_52() , #pred^#(#pos(#s(#s(@x)))) -> c_53() , #succ^#(#0()) -> c_54() , #succ^#(#neg(#s(#0()))) -> c_55() , #succ^#(#neg(#s(#s(@x)))) -> c_56() , #succ^#(#pos(#s(@x))) -> c_57() , #natadd^#(#0(), @y) -> c_60() , #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult(@t, @acc) -> bftMult'(tuple#2(::(@t, nil()), nil()), @acc) , bftMult'(@queue, @acc) -> bftMult'#1(bftMult'#2(@queue), @acc) , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , bftMult'#1(tuple#2(@elem, @queue), @acc) -> bftMult'#3(@elem, @acc, @queue) , bftMult'#3(::(@t, @_@3), @acc, @queue) -> bftMult'#4(@t, @acc, @queue) , bftMult'#3(nil(), @acc, @queue) -> @acc , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , bftMult'#4(leaf(), @acc, @queue) -> bftMult'(@queue, @acc) , bftMult'#4(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , bftMult'#5(@queue', @acc, @y) -> bftMult'(@queue', matrixMult(@acc, @y)) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) Consider the dependency graph 1: *^#(@x, @y) -> c_1(#mult^#(@x, @y)) -->_1 #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) :44 -->_1 #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) :43 -->_1 #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) :41 -->_1 #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) :40 -->_1 #mult^#(#pos(@x), #0()) -> c_42() :42 -->_1 #mult^#(#neg(@x), #0()) -> c_39() :39 -->_1 #mult^#(#0(), #pos(@y)) -> c_38() :38 -->_1 #mult^#(#0(), #neg(@y)) -> c_37() :37 -->_1 #mult^#(#0(), #0()) -> c_36() :36 2: +^#(@x, @y) -> c_2(#add^#(@x, @y)) -->_1 #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :49 -->_1 #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) :48 -->_1 #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :47 -->_1 #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) :46 -->_1 #add^#(#0(), @y) -> c_45() :45 3: appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) -->_1 appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) :4 -->_1 appendreverse#1^#(nil(), @sofar) -> c_5() :5 4: appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) -->_1 appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) :3 5: appendreverse#1^#(nil(), @sofar) -> c_5() 6: bftMult^#(@t, @acc) -> c_6(bftMult'^#(tuple#2(::(@t, nil()), nil()), @acc)) -->_1 bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) :7 7: bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) -->_2 bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) :9 -->_1 bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) :8 8: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) -->_1 bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) :11 -->_1 bftMult'#3^#(nil(), @acc, @queue) -> c_11() :12 9: bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) -->_1 dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) :10 10: dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) -->_1 dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) :16 -->_1 dequeue#1^#(::(@t, @ts), @inq) -> c_24() :15 11: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) -->_1 bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) :14 -->_1 bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) :13 12: bftMult'#3^#(nil(), @acc, @queue) -> c_11() 13: bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) -->_1 bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) :7 14: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) -->_3 enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) :18 -->_2 enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) :18 -->_1 bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) :17 15: dequeue#1^#(::(@t, @ts), @inq) -> c_24() 16: dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) -->_2 reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) :33 -->_1 dequeue#2^#(nil()) -> c_28() :32 -->_1 dequeue#2^#(::(@t, @ts)) -> c_27() :31 17: bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) -->_2 matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) :20 -->_1 bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) :7 18: enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) -->_1 enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() :19 19: enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() 20: matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) -->_1 matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) :21 -->_1 matrixMult#1^#(nil(), @m2) -> c_35() :22 21: matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) -->_1 computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) :23 -->_2 matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) :20 22: matrixMult#1^#(nil(), @m2) -> c_35() 23: computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) -->_1 computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) :24 -->_1 computeLine#1^#(nil(), @acc, @m) -> c_20() :25 24: computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) -->_1 computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) :26 -->_1 computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() :27 25: computeLine#1^#(nil(), @acc, @m) -> c_20() 26: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) -->_2 lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) :28 -->_1 computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) :23 27: computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() 28: lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) -->_1 lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) :29 -->_1 lineMult#1^#(nil(), @l2, @n) -> c_31() :30 29: lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) -->_1 lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) :35 -->_1 lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) :34 30: lineMult#1^#(nil(), @l2, @n) -> c_31() 31: dequeue#2^#(::(@t, @ts)) -> c_27() 32: dequeue#2^#(nil()) -> c_28() 33: reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) -->_1 appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) :3 34: lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) -->_3 lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) :28 -->_1 +^#(@x, @y) -> c_2(#add^#(@x, @y)) :2 -->_2 *^#(@x, @y) -> c_1(#mult^#(@x, @y)) :1 35: lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) -->_2 lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) :28 -->_1 *^#(@x, @y) -> c_1(#mult^#(@x, @y)) :1 36: #mult^#(#0(), #0()) -> c_36() 37: #mult^#(#0(), #neg(@y)) -> c_37() 38: #mult^#(#0(), #pos(@y)) -> c_38() 39: #mult^#(#neg(@x), #0()) -> c_39() 40: #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :51 -->_1 #natmult^#(#0(), @y) -> c_58() :50 41: #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :51 -->_1 #natmult^#(#0(), @y) -> c_58() :50 42: #mult^#(#pos(@x), #0()) -> c_42() 43: #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :51 -->_1 #natmult^#(#0(), @y) -> c_58() :50 44: #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :51 -->_1 #natmult^#(#0(), @y) -> c_58() :50 45: #add^#(#0(), @y) -> c_45() 46: #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) -->_1 #pred^#(#pos(#s(#s(@x)))) -> c_53() :55 -->_1 #pred^#(#pos(#s(#0()))) -> c_52() :54 -->_1 #pred^#(#neg(#s(@x))) -> c_51() :53 -->_1 #pred^#(#0()) -> c_50() :52 47: #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) -->_2 #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :49 -->_2 #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) :48 -->_1 #pred^#(#pos(#s(#s(@x)))) -> c_53() :55 -->_1 #pred^#(#pos(#s(#0()))) -> c_52() :54 -->_1 #pred^#(#neg(#s(@x))) -> c_51() :53 -->_1 #pred^#(#0()) -> c_50() :52 48: #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) -->_1 #succ^#(#pos(#s(@x))) -> c_57() :59 -->_1 #succ^#(#neg(#s(#s(@x)))) -> c_56() :58 -->_1 #succ^#(#neg(#s(#0()))) -> c_55() :57 -->_1 #succ^#(#0()) -> c_54() :56 49: #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) -->_1 #succ^#(#pos(#s(@x))) -> c_57() :59 -->_1 #succ^#(#neg(#s(#s(@x)))) -> c_56() :58 -->_1 #succ^#(#neg(#s(#0()))) -> c_55() :57 -->_1 #succ^#(#0()) -> c_54() :56 -->_2 #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :49 -->_2 #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) :48 50: #natmult^#(#0(), @y) -> c_58() 51: #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) -->_1 #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) :61 -->_1 #natadd^#(#0(), @y) -> c_60() :60 -->_2 #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :51 -->_2 #natmult^#(#0(), @y) -> c_58() :50 52: #pred^#(#0()) -> c_50() 53: #pred^#(#neg(#s(@x))) -> c_51() 54: #pred^#(#pos(#s(#0()))) -> c_52() 55: #pred^#(#pos(#s(#s(@x)))) -> c_53() 56: #succ^#(#0()) -> c_54() 57: #succ^#(#neg(#s(#0()))) -> c_55() 58: #succ^#(#neg(#s(#s(@x)))) -> c_56() 59: #succ^#(#pos(#s(@x))) -> c_57() 60: #natadd^#(#0(), @y) -> c_60() 61: #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) -->_1 #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) :61 -->_1 #natadd^#(#0(), @y) -> c_60() :60 Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { bftMult^#(@t, @acc) -> c_6(bftMult'^#(tuple#2(::(@t, nil()), nil()), @acc)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { *^#(@x, @y) -> c_1(#mult^#(@x, @y)) , +^#(@x, @y) -> c_2(#add^#(@x, @y)) , appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) , appendreverse#1^#(nil(), @sofar) -> c_5() , bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#3^#(nil(), @acc, @queue) -> c_11() , bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , dequeue#1^#(::(@t, @ts), @inq) -> c_24() , dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) , enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() , matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , matrixMult#1^#(nil(), @m2) -> c_35() , computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#1^#(nil(), @acc, @m) -> c_20() , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() , lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#1^#(nil(), @l2, @n) -> c_31() , dequeue#2^#(::(@t, @ts)) -> c_27() , dequeue#2^#(nil()) -> c_28() , reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) } Weak DPs: { #mult^#(#0(), #0()) -> c_36() , #mult^#(#0(), #neg(@y)) -> c_37() , #mult^#(#0(), #pos(@y)) -> c_38() , #mult^#(#neg(@x), #0()) -> c_39() , #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_42() , #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_45() , #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_58() , #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_50() , #pred^#(#neg(#s(@x))) -> c_51() , #pred^#(#pos(#s(#0()))) -> c_52() , #pred^#(#pos(#s(#s(@x)))) -> c_53() , #succ^#(#0()) -> c_54() , #succ^#(#neg(#s(#0()))) -> c_55() , #succ^#(#neg(#s(#s(@x)))) -> c_56() , #succ^#(#pos(#s(@x))) -> c_57() , #natadd^#(#0(), @y) -> c_60() , #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult(@t, @acc) -> bftMult'(tuple#2(::(@t, nil()), nil()), @acc) , bftMult'(@queue, @acc) -> bftMult'#1(bftMult'#2(@queue), @acc) , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , bftMult'#1(tuple#2(@elem, @queue), @acc) -> bftMult'#3(@elem, @acc, @queue) , bftMult'#3(::(@t, @_@3), @acc, @queue) -> bftMult'#4(@t, @acc, @queue) , bftMult'#3(nil(), @acc, @queue) -> @acc , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , bftMult'#4(leaf(), @acc, @queue) -> bftMult'(@queue, @acc) , bftMult'#4(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , bftMult'#5(@queue', @acc, @y) -> bftMult'(@queue', matrixMult(@acc, @y)) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We estimate the number of application of {1,2,5,11,14,18,21,24,26,29,30,31} by applications of Pre({1,2,5,11,14,18,21,24,26,29,30,31}) = {3,7,9,15,17,19,22,23,27,33,34}. Here rules are labeled as follows: DPs: { 1: *^#(@x, @y) -> c_1(#mult^#(@x, @y)) , 2: +^#(@x, @y) -> c_2(#add^#(@x, @y)) , 3: appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) , 4: appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) , 5: appendreverse#1^#(nil(), @sofar) -> c_5() , 6: bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , 7: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) , 8: bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) , 9: dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) , 10: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) , 11: bftMult'#3^#(nil(), @acc, @queue) -> c_11() , 12: bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) , 13: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , 14: dequeue#1^#(::(@t, @ts), @inq) -> c_24() , 15: dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , 16: bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , 17: enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) , 18: enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() , 19: matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) , 20: matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , 21: matrixMult#1^#(nil(), @m2) -> c_35() , 22: computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) , 23: computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) , 24: computeLine#1^#(nil(), @acc, @m) -> c_20() , 25: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , 26: computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() , 27: lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) , 28: lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) , 29: lineMult#1^#(nil(), @l2, @n) -> c_31() , 30: dequeue#2^#(::(@t, @ts)) -> c_27() , 31: dequeue#2^#(nil()) -> c_28() , 32: reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) , 33: lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , 34: lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) , 35: #mult^#(#0(), #0()) -> c_36() , 36: #mult^#(#0(), #neg(@y)) -> c_37() , 37: #mult^#(#0(), #pos(@y)) -> c_38() , 38: #mult^#(#neg(@x), #0()) -> c_39() , 39: #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) , 40: #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) , 41: #mult^#(#pos(@x), #0()) -> c_42() , 42: #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) , 43: #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) , 44: #add^#(#0(), @y) -> c_45() , 45: #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) , 46: #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 47: #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) , 48: #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 49: #natmult^#(#0(), @y) -> c_58() , 50: #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , 51: #pred^#(#0()) -> c_50() , 52: #pred^#(#neg(#s(@x))) -> c_51() , 53: #pred^#(#pos(#s(#0()))) -> c_52() , 54: #pred^#(#pos(#s(#s(@x)))) -> c_53() , 55: #succ^#(#0()) -> c_54() , 56: #succ^#(#neg(#s(#0()))) -> c_55() , 57: #succ^#(#neg(#s(#s(@x)))) -> c_56() , 58: #succ^#(#pos(#s(@x))) -> c_57() , 59: #natadd^#(#0(), @y) -> c_60() , 60: #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) , matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) , reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) } Weak DPs: { *^#(@x, @y) -> c_1(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_36() , #mult^#(#0(), #neg(@y)) -> c_37() , #mult^#(#0(), #pos(@y)) -> c_38() , #mult^#(#neg(@x), #0()) -> c_39() , #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_42() , #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_2(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_45() , #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , appendreverse#1^#(nil(), @sofar) -> c_5() , bftMult'#3^#(nil(), @acc, @queue) -> c_11() , dequeue#1^#(::(@t, @ts), @inq) -> c_24() , enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() , matrixMult#1^#(nil(), @m2) -> c_35() , computeLine#1^#(nil(), @acc, @m) -> c_20() , computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() , lineMult#1^#(nil(), @l2, @n) -> c_31() , dequeue#2^#(::(@t, @ts)) -> c_27() , dequeue#2^#(nil()) -> c_28() , #natmult^#(#0(), @y) -> c_58() , #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_50() , #pred^#(#neg(#s(@x))) -> c_51() , #pred^#(#pos(#s(#0()))) -> c_52() , #pred^#(#pos(#s(#s(@x)))) -> c_53() , #succ^#(#0()) -> c_54() , #succ^#(#neg(#s(#0()))) -> c_55() , #succ^#(#neg(#s(#s(@x)))) -> c_56() , #succ^#(#pos(#s(@x))) -> c_57() , #natadd^#(#0(), @y) -> c_60() , #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult(@t, @acc) -> bftMult'(tuple#2(::(@t, nil()), nil()), @acc) , bftMult'(@queue, @acc) -> bftMult'#1(bftMult'#2(@queue), @acc) , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , bftMult'#1(tuple#2(@elem, @queue), @acc) -> bftMult'#3(@elem, @acc, @queue) , bftMult'#3(::(@t, @_@3), @acc, @queue) -> bftMult'#4(@t, @acc, @queue) , bftMult'#3(nil(), @acc, @queue) -> @acc , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , bftMult'#4(leaf(), @acc, @queue) -> bftMult'(@queue, @acc) , bftMult'#4(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , bftMult'#5(@queue', @acc, @y) -> bftMult'(@queue', matrixMult(@acc, @y)) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We estimate the number of application of {12} by applications of Pre({12}) = {9}. Here rules are labeled as follows: DPs: { 1: appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) , 2: appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) , 3: bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , 4: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) , 5: bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) , 6: dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) , 7: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) , 8: bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) , 9: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , 10: dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , 11: bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , 12: enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) , 13: matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) , 14: matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , 15: computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) , 16: computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) , 17: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , 18: lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) , 19: lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) , 20: reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) , 21: lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , 22: lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) , 23: *^#(@x, @y) -> c_1(#mult^#(@x, @y)) , 24: #mult^#(#0(), #0()) -> c_36() , 25: #mult^#(#0(), #neg(@y)) -> c_37() , 26: #mult^#(#0(), #pos(@y)) -> c_38() , 27: #mult^#(#neg(@x), #0()) -> c_39() , 28: #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) , 29: #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) , 30: #mult^#(#pos(@x), #0()) -> c_42() , 31: #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) , 32: #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) , 33: +^#(@x, @y) -> c_2(#add^#(@x, @y)) , 34: #add^#(#0(), @y) -> c_45() , 35: #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) , 36: #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 37: #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) , 38: #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 39: appendreverse#1^#(nil(), @sofar) -> c_5() , 40: bftMult'#3^#(nil(), @acc, @queue) -> c_11() , 41: dequeue#1^#(::(@t, @ts), @inq) -> c_24() , 42: enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() , 43: matrixMult#1^#(nil(), @m2) -> c_35() , 44: computeLine#1^#(nil(), @acc, @m) -> c_20() , 45: computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() , 46: lineMult#1^#(nil(), @l2, @n) -> c_31() , 47: dequeue#2^#(::(@t, @ts)) -> c_27() , 48: dequeue#2^#(nil()) -> c_28() , 49: #natmult^#(#0(), @y) -> c_58() , 50: #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , 51: #pred^#(#0()) -> c_50() , 52: #pred^#(#neg(#s(@x))) -> c_51() , 53: #pred^#(#pos(#s(#0()))) -> c_52() , 54: #pred^#(#pos(#s(#s(@x)))) -> c_53() , 55: #succ^#(#0()) -> c_54() , 56: #succ^#(#neg(#s(#0()))) -> c_55() , 57: #succ^#(#neg(#s(#s(@x)))) -> c_56() , 58: #succ^#(#pos(#s(@x))) -> c_57() , 59: #natadd^#(#0(), @y) -> c_60() , 60: #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) , reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) } Weak DPs: { *^#(@x, @y) -> c_1(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_36() , #mult^#(#0(), #neg(@y)) -> c_37() , #mult^#(#0(), #pos(@y)) -> c_38() , #mult^#(#neg(@x), #0()) -> c_39() , #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_42() , #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_2(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_45() , #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , appendreverse#1^#(nil(), @sofar) -> c_5() , bftMult'#3^#(nil(), @acc, @queue) -> c_11() , dequeue#1^#(::(@t, @ts), @inq) -> c_24() , enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) , enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() , matrixMult#1^#(nil(), @m2) -> c_35() , computeLine#1^#(nil(), @acc, @m) -> c_20() , computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() , lineMult#1^#(nil(), @l2, @n) -> c_31() , dequeue#2^#(::(@t, @ts)) -> c_27() , dequeue#2^#(nil()) -> c_28() , #natmult^#(#0(), @y) -> c_58() , #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_50() , #pred^#(#neg(#s(@x))) -> c_51() , #pred^#(#pos(#s(#0()))) -> c_52() , #pred^#(#pos(#s(#s(@x)))) -> c_53() , #succ^#(#0()) -> c_54() , #succ^#(#neg(#s(#0()))) -> c_55() , #succ^#(#neg(#s(#s(@x)))) -> c_56() , #succ^#(#pos(#s(@x))) -> c_57() , #natadd^#(#0(), @y) -> c_60() , #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult(@t, @acc) -> bftMult'(tuple#2(::(@t, nil()), nil()), @acc) , bftMult'(@queue, @acc) -> bftMult'#1(bftMult'#2(@queue), @acc) , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , bftMult'#1(tuple#2(@elem, @queue), @acc) -> bftMult'#3(@elem, @acc, @queue) , bftMult'#3(::(@t, @_@3), @acc, @queue) -> bftMult'#4(@t, @acc, @queue) , bftMult'#3(nil(), @acc, @queue) -> @acc , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , bftMult'#4(leaf(), @acc, @queue) -> bftMult'(@queue, @acc) , bftMult'#4(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , bftMult'#5(@queue', @acc, @y) -> bftMult'(@queue', matrixMult(@acc, @y)) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { *^#(@x, @y) -> c_1(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_36() , #mult^#(#0(), #neg(@y)) -> c_37() , #mult^#(#0(), #pos(@y)) -> c_38() , #mult^#(#neg(@x), #0()) -> c_39() , #mult^#(#neg(@x), #neg(@y)) -> c_40(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_41(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_42() , #mult^#(#pos(@x), #neg(@y)) -> c_43(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_44(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_2(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_45() , #add^#(#neg(#s(#0())), @y) -> c_46(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_47(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_48(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_49(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , appendreverse#1^#(nil(), @sofar) -> c_5() , bftMult'#3^#(nil(), @acc, @queue) -> c_11() , dequeue#1^#(::(@t, @ts), @inq) -> c_24() , enqueue^#(@t, @queue) -> c_15(enqueue#1^#(@queue, @t)) , enqueue#1^#(tuple#2(@outq, @inq), @t) -> c_29() , matrixMult#1^#(nil(), @m2) -> c_35() , computeLine#1^#(nil(), @acc, @m) -> c_20() , computeLine#2^#(nil(), @acc, @x, @xs) -> c_22() , lineMult#1^#(nil(), @l2, @n) -> c_31() , dequeue#2^#(::(@t, @ts)) -> c_27() , dequeue#2^#(nil()) -> c_28() , #natmult^#(#0(), @y) -> c_58() , #natmult^#(#s(@x), @y) -> c_59(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_50() , #pred^#(#neg(#s(@x))) -> c_51() , #pred^#(#pos(#s(#0()))) -> c_52() , #pred^#(#pos(#s(#s(@x)))) -> c_53() , #succ^#(#0()) -> c_54() , #succ^#(#neg(#s(#0()))) -> c_55() , #succ^#(#neg(#s(#s(@x)))) -> c_56() , #succ^#(#pos(#s(@x))) -> c_57() , #natadd^#(#0(), @y) -> c_60() , #natadd^#(#s(@x), @y) -> c_61(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_3(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_4(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'^#(@queue, @acc) -> c_7(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_9(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_8(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_12(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_10(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_13(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> c_16(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_17(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_34(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_18(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_19(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_21(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_23(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_30(lineMult#2^#(@l2, @n, @x, @xs)) , reverse^#(@xs) -> c_26(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult(@t, @acc) -> bftMult'(tuple#2(::(@t, nil()), nil()), @acc) , bftMult'(@queue, @acc) -> bftMult'#1(bftMult'#2(@queue), @acc) , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , bftMult'#1(tuple#2(@elem, @queue), @acc) -> bftMult'#3(@elem, @acc, @queue) , bftMult'#3(::(@t, @_@3), @acc, @queue) -> bftMult'#4(@t, @acc, @queue) , bftMult'#3(nil(), @acc, @queue) -> @acc , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , bftMult'#4(leaf(), @acc, @queue) -> bftMult'(@queue, @acc) , bftMult'#4(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , bftMult'#5(@queue', @acc, @y) -> bftMult'(@queue', matrixMult(@acc, @y)) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_14(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y), enqueue^#(@t2, enqueue(@t1, @queue)), enqueue^#(@t1, @queue)) , dequeue#1^#(nil(), @inq) -> c_25(dequeue#2^#(reverse(@inq)), reverse^#(@inq)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_32(+^#(*(@x, @n), @y), *^#(@x, @n), lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_33(*^#(@x, @n), lineMult^#(@n, @xs, nil())) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_7(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_8(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_9(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , dequeue#1^#(nil(), @inq) -> c_10(reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> c_11(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_14(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_15(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_17(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_18(lineMult#2^#(@l2, @n, @x, @xs)) , reverse^#(@xs) -> c_19(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_20(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_21(lineMult^#(@n, @xs, nil())) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult(@t, @acc) -> bftMult'(tuple#2(::(@t, nil()), nil()), @acc) , bftMult'(@queue, @acc) -> bftMult'#1(bftMult'#2(@queue), @acc) , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , bftMult'#1(tuple#2(@elem, @queue), @acc) -> bftMult'#3(@elem, @acc, @queue) , bftMult'#3(::(@t, @_@3), @acc, @queue) -> bftMult'#4(@t, @acc, @queue) , bftMult'#3(nil(), @acc, @queue) -> @acc , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , bftMult'#4(leaf(), @acc, @queue) -> bftMult'(@queue, @acc) , bftMult'#4(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , bftMult'#5(@queue', @acc, @y) -> bftMult'(@queue', matrixMult(@acc, @y)) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We replace rewrite rules by usable rules: Weak Usable Rules: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_7(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_8(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_9(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , dequeue#1^#(nil(), @inq) -> c_10(reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> c_11(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_14(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_15(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_17(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_18(lineMult#2^#(@l2, @n, @x, @xs)) , reverse^#(@xs) -> c_19(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_20(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_21(lineMult^#(@n, @xs, nil())) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We decompose the input problem according to the dependency graph into the upper component { bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_7(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_8(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_9(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_11(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) } and lower component { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , dequeue#1^#(nil(), @inq) -> c_10(reverse^#(@inq)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_14(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_15(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_17(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_18(lineMult#2^#(@l2, @n, @x, @xs)) , reverse^#(@xs) -> c_19(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_20(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_21(lineMult^#(@n, @xs, nil())) } Further, following extension rules are added to the lower component. { bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'^#(@queue, @acc) -> bftMult'#2^#(@queue) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_7(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_8(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_9(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_11(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc), bftMult'#2^#(@queue)) , bftMult'#5^#(@queue', @acc, @y) -> c_11(bftMult'^#(@queue', matrixMult(@acc, @y)), matrixMult^#(@acc, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bftMult'^#(@queue, @acc) -> c_1(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_2(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_3(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_4(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_5(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_6(bftMult'^#(@queue', matrixMult(@acc, @y))) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 4: bftMult'#4^#(leaf(), @acc, @queue) -> c_4(bftMult'^#(@queue, @acc)) , 5: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_5(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [0] [nil] = [0] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [0] [bftMult'#2](x1) = [1] x1 + [0] [dequeue](x1, x2) = [1] x1 + [1] x2 + [0] [leaf] = [1] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [enqueue](x1, x2) = [1] x1 + [1] x2 + [0] [matrixMult](x1, x2) = [0] [computeLine](x1, x2, x3) = [0] [computeLine#1](x1, x2, x3) = [1] x2 + [0] [computeLine#2](x1, x2, x3, x4) = [0] [lineMult](x1, x2, x3) = [0] [dequeue#1](x1, x2) = [1] x1 + [1] x2 + [0] [reverse](x1) = [1] x1 + [0] [dequeue#2](x1) = [1] x1 + [0] [enqueue#1](x1, x2) = [1] x1 + [1] x2 + [0] [lineMult#1](x1, x2, x3) = [1] x1 + [0] [lineMult#2](x1, x2, x3, x4) = [1] x2 + [1] x3 + [0] [matrixMult#1](x1, x2) = [0] [#0] = [0] [#s](x1) = [1] x1 + [0] [#neg](x1) = [0] [#pred](x1) = [0] [#pos](x1) = [1] x1 + [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [1] x1 + [0] [bftMult'#1^#](x1, x2) = [1] x1 + [0] [bftMult'#2^#](x1) = [0] [dequeue^#](x1, x2) = [0] [bftMult'#3^#](x1, x2, x3) = [1] x1 + [1] x3 + [0] [bftMult'#4^#](x1, x2, x3) = [1] x1 + [1] x3 + [0] [dequeue#1^#](x1, x2) = [0] [bftMult'#5^#](x1, x2, x3) = [1] x1 + [0] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [0] [matrixMult#1^#](x1, x2) = [0] [computeLine^#](x1, x2, x3) = [0] [computeLine#1^#](x1, x2, x3) = [0] [computeLine#2^#](x1, x2, x3, x4) = [0] [lineMult^#](x1, x2, x3) = [0] [lineMult#1^#](x1, x2, x3) = [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [0] [lineMult#2^#](x1, x2, x3, x4) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_3](x1, x2) = [0] [c_4](x1) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_11](x1, x2) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] This order satisfies following ordering constraints [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [0] >= [1] @a + [1] @as + [1] @sofar + [0] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bftMult'#2(tuple#2(@dequeue@1, @dequeue@2))] = [1] @dequeue@1 + [1] @dequeue@2 + [0] >= [1] @dequeue@1 + [1] @dequeue@2 + [0] = [dequeue(@dequeue@1, @dequeue@2)] [dequeue(@outq, @inq)] = [1] @inq + [1] @outq + [0] >= [1] @inq + [1] @outq + [0] = [dequeue#1(@outq, @inq)] [enqueue(@t, @queue)] = [1] @queue + [1] @t + [0] >= [1] @queue + [1] @t + [0] = [enqueue#1(@queue, @t)] [dequeue#1(::(@t, @ts), @inq)] = [1] @inq + [1] @t + [1] @ts + [0] >= [1] @inq + [1] @t + [1] @ts + [0] = [tuple#2(::(@t, nil()), tuple#2(@ts, @inq))] [dequeue#1(nil(), @inq)] = [1] @inq + [0] >= [1] @inq + [0] = [dequeue#2(reverse(@inq))] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [dequeue#2(::(@t, @ts))] = [1] @t + [1] @ts + [0] >= [1] @t + [1] @ts + [0] = [tuple#2(::(@t, nil()), tuple#2(@ts, nil()))] [dequeue#2(nil())] = [0] >= [0] = [tuple#2(nil(), tuple#2(nil(), nil()))] [enqueue#1(tuple#2(@outq, @inq), @t)] = [1] @inq + [1] @outq + [1] @t + [0] >= [1] @inq + [1] @outq + [1] @t + [0] = [tuple#2(@outq, ::(@t, @inq))] [bftMult'^#(@queue, @acc)] = [1] @queue + [0] >= [1] @queue + [0] = [c_1(bftMult'#1^#(bftMult'#2(@queue), @acc))] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [1] @elem + [1] @queue + [0] >= [1] @elem + [1] @queue + [0] = [c_2(bftMult'#3^#(@elem, @acc, @queue))] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [1] @_@3 + [1] @queue + [1] @t + [0] >= [1] @queue + [1] @t + [0] = [c_3(bftMult'#4^#(@t, @acc, @queue))] [bftMult'#4^#(leaf(), @acc, @queue)] = [1] @queue + [1] > [1] @queue + [0] = [c_4(bftMult'^#(@queue, @acc))] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [1] > [1] @queue + [1] @t1 + [1] @t2 + [0] = [c_5(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [0] >= [1] @queue' + [0] = [c_6(bftMult'^#(@queue', matrixMult(@acc, @y)))] Consider the set of all dependency pairs DPs: { 1: bftMult'^#(@queue, @acc) -> c_1(bftMult'#1^#(bftMult'#2(@queue), @acc)) , 2: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_2(bftMult'#3^#(@elem, @acc, @queue)) , 3: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_3(bftMult'#4^#(@t, @acc, @queue)) , 4: bftMult'#4^#(leaf(), @acc, @queue) -> c_4(bftMult'^#(@queue, @acc)) , 5: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_5(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , 6: bftMult'#5^#(@queue', @acc, @y) -> c_6(bftMult'^#(@queue', matrixMult(@acc, @y))) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {4,5}. These cover all (indirect) predecessors of dependency pairs {1,2,3,4,5,6}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { bftMult'^#(@queue, @acc) -> c_1(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_2(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_3(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_4(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_5(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_6(bftMult'^#(@queue', matrixMult(@acc, @y))) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bftMult'^#(@queue, @acc) -> c_1(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_2(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_3(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_4(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_5(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_6(bftMult'^#(@queue', matrixMult(@acc, @y))) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , dequeue#1^#(nil(), @inq) -> c_10(reverse^#(@inq)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_14(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_15(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_17(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_18(lineMult#2^#(@l2, @n, @x, @xs)) , reverse^#(@xs) -> c_19(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_20(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_21(lineMult^#(@n, @xs, nil())) } Weak DPs: { bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'^#(@queue, @acc) -> bftMult'#2^#(@queue) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 2: appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , 20: bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) } Trs: { computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_10) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1, 2}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1, 2}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1}, Uargs(c_21) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [0] [#add](x1, x2) = [1] x2 + [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [nil] = [0] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [0] [bftMult'#2](x1) = [1] x1 + [0] [dequeue](x1, x2) = [1] x1 + [1] x2 + [0] [leaf] = [0] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [enqueue](x1, x2) = [1] x1 + [1] x2 + [1] [matrixMult](x1, x2) = [0] [computeLine](x1, x2, x3) = [0] [computeLine#1](x1, x2, x3) = [1] x1 + [1] x2 + [0] [computeLine#2](x1, x2, x3, x4) = [1] [lineMult](x1, x2, x3) = [0] [dequeue#1](x1, x2) = [1] x1 + [1] x2 + [0] [reverse](x1) = [1] x1 + [0] [dequeue#2](x1) = [1] x1 + [0] [enqueue#1](x1, x2) = [1] x1 + [1] x2 + [1] [lineMult#1](x1, x2, x3) = [1] [lineMult#2](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMult#1](x1, x2) = [1] x1 + [0] [#0] = [0] [#s](x1) = [0] [#neg](x1) = [0] [#pred](x1) = [0] [#pos](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [1] x1 + [0] [appendreverse#1^#](x1, x2) = [1] x1 + [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [1] x1 + [0] [bftMult'#1^#](x1, x2) = [1] x1 + [0] [bftMult'#2^#](x1) = [1] x1 + [0] [dequeue^#](x1, x2) = [1] x2 + [0] [bftMult'#3^#](x1, x2, x3) = [1] x1 + [1] x3 + [0] [bftMult'#4^#](x1, x2, x3) = [1] x1 + [1] x3 + [1] [dequeue#1^#](x1, x2) = [1] x2 + [0] [bftMult'#5^#](x1, x2, x3) = [1] x1 + [1] x3 + [0] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [0] [matrixMult#1^#](x1, x2) = [0] [computeLine^#](x1, x2, x3) = [0] [computeLine#1^#](x1, x2, x3) = [0] [computeLine#2^#](x1, x2, x3, x4) = [0] [lineMult^#](x1, x2, x3) = [0] [lineMult#1^#](x1, x2, x3) = [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [1] x1 + [0] [lineMult#2^#](x1, x2, x3, x4) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1, x2) = [1] x1 + [1] x2 + [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1, x2) = [1] x1 + [1] x2 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1) = [1] x1 + [0] [c_21](x1) = [1] x1 + [0] This order satisfies following ordering constraints [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [1] >= [1] @a + [1] @as + [1] @sofar + [1] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bftMult'#2(tuple#2(@dequeue@1, @dequeue@2))] = [1] @dequeue@1 + [1] @dequeue@2 + [0] >= [1] @dequeue@1 + [1] @dequeue@2 + [0] = [dequeue(@dequeue@1, @dequeue@2)] [dequeue(@outq, @inq)] = [1] @inq + [1] @outq + [0] >= [1] @inq + [1] @outq + [0] = [dequeue#1(@outq, @inq)] [enqueue(@t, @queue)] = [1] @queue + [1] @t + [1] >= [1] @queue + [1] @t + [1] = [enqueue#1(@queue, @t)] [dequeue#1(::(@t, @ts), @inq)] = [1] @inq + [1] @t + [1] @ts + [1] >= [1] @inq + [1] @t + [1] @ts + [1] = [tuple#2(::(@t, nil()), tuple#2(@ts, @inq))] [dequeue#1(nil(), @inq)] = [1] @inq + [0] >= [1] @inq + [0] = [dequeue#2(reverse(@inq))] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [dequeue#2(::(@t, @ts))] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [tuple#2(::(@t, nil()), tuple#2(@ts, nil()))] [dequeue#2(nil())] = [0] >= [0] = [tuple#2(nil(), tuple#2(nil(), nil()))] [enqueue#1(tuple#2(@outq, @inq), @t)] = [1] @inq + [1] @outq + [1] @t + [1] >= [1] @inq + [1] @outq + [1] @t + [1] = [tuple#2(@outq, ::(@t, @inq))] [appendreverse^#(@toreverse, @sofar)] = [1] @toreverse + [0] >= [1] @toreverse + [0] = [c_1(appendreverse#1^#(@toreverse, @sofar))] [appendreverse#1^#(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] > [1] @as + [0] = [c_2(appendreverse^#(@as, ::(@a, @sofar)))] [bftMult'^#(@queue, @acc)] = [1] @queue + [0] >= [1] @queue + [0] = [bftMult'#1^#(bftMult'#2(@queue), @acc)] [bftMult'^#(@queue, @acc)] = [1] @queue + [0] >= [1] @queue + [0] = [bftMult'#2^#(@queue)] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [1] @elem + [1] @queue + [0] >= [1] @elem + [1] @queue + [0] = [bftMult'#3^#(@elem, @acc, @queue)] [bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2))] = [1] @dequeue@1 + [1] @dequeue@2 + [0] >= [1] @dequeue@2 + [0] = [c_5(dequeue^#(@dequeue@1, @dequeue@2))] [dequeue^#(@outq, @inq)] = [1] @inq + [0] >= [1] @inq + [0] = [c_6(dequeue#1^#(@outq, @inq))] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [1] @_@3 + [1] @queue + [1] @t + [1] >= [1] @queue + [1] @t + [1] = [bftMult'#4^#(@t, @acc, @queue)] [bftMult'#4^#(leaf(), @acc, @queue)] = [1] @queue + [1] > [1] @queue + [0] = [bftMult'^#(@queue, @acc)] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [2] >= [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [2] = [bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)] [dequeue#1^#(nil(), @inq)] = [1] @inq + [0] >= [1] @inq + [0] = [c_10(reverse^#(@inq))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [1] @y + [0] >= [1] @queue' + [0] = [bftMult'^#(@queue', matrixMult(@acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [1] @y + [0] >= [0] = [matrixMult^#(@acc, @y)] [matrixMult^#(@m1, @m2)] = [0] >= [0] = [c_12(matrixMult#1^#(@m1, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [0] >= [0] = [c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2))] [computeLine^#(@line, @m, @acc)] = [0] >= [0] = [c_14(computeLine#1^#(@line, @acc, @m))] [computeLine#1^#(::(@x, @xs), @acc, @m)] = [0] >= [0] = [c_15(computeLine#2^#(@m, @acc, @x, @xs))] [computeLine#2^#(::(@l, @ls), @acc, @x, @xs)] = [0] >= [0] = [c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc))] [lineMult^#(@n, @l1, @l2)] = [0] >= [0] = [c_17(lineMult#1^#(@l1, @l2, @n))] [lineMult#1^#(::(@x, @xs), @l2, @n)] = [0] >= [0] = [c_18(lineMult#2^#(@l2, @n, @x, @xs))] [reverse^#(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [c_19(appendreverse^#(@xs, nil()))] [lineMult#2^#(::(@y, @ys), @n, @x, @xs)] = [0] >= [0] = [c_20(lineMult^#(@n, @xs, @ys))] [lineMult#2^#(nil(), @n, @x, @xs)] = [0] >= [0] = [c_21(lineMult^#(@n, @xs, nil()))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) , dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , dequeue#1^#(nil(), @inq) -> c_10(reverse^#(@inq)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_14(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_15(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_17(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_18(lineMult#2^#(@l2, @n, @x, @xs)) , reverse^#(@xs) -> c_19(appendreverse^#(@xs, nil())) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_20(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_21(lineMult^#(@n, @xs, nil())) } Weak DPs: { appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'^#(@queue, @acc) -> bftMult'#2^#(@queue) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 1: appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , 3: dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , 20: bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , 23: bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_10) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1, 2}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1, 2}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1}, Uargs(c_21) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [0] [#add](x1, x2) = [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [nil] = [0] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [1] [bftMult'#2](x1) = [1] x1 + [1] [dequeue](x1, x2) = [1] x1 + [1] x2 + [2] [leaf] = [0] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [enqueue](x1, x2) = [1] x1 + [1] x2 + [1] [matrixMult](x1, x2) = [0] [computeLine](x1, x2, x3) = [0] [computeLine#1](x1, x2, x3) = [2] x2 + [2] x3 + [0] [computeLine#2](x1, x2, x3, x4) = [2] x4 + [0] [lineMult](x1, x2, x3) = [0] [dequeue#1](x1, x2) = [1] x1 + [1] x2 + [2] [reverse](x1) = [1] x1 + [0] [dequeue#2](x1) = [1] x1 + [2] [enqueue#1](x1, x2) = [1] x1 + [1] x2 + [1] [lineMult#1](x1, x2, x3) = [2] x2 + [2] x3 + [0] [lineMult#2](x1, x2, x3, x4) = [2] x2 + [2] x3 + [1] x4 + [1] [matrixMult#1](x1, x2) = [1] x1 + [0] [#0] = [0] [#s](x1) = [0] [#neg](x1) = [0] [#pred](x1) = [0] [#pos](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [1] x1 + [1] [appendreverse#1^#](x1, x2) = [1] x1 + [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [1] x1 + [1] [bftMult'#1^#](x1, x2) = [1] x1 + [0] [bftMult'#2^#](x1) = [1] x1 + [1] [dequeue^#](x1, x2) = [1] x2 + [2] [bftMult'#3^#](x1, x2, x3) = [1] x1 + [1] x3 + [1] [bftMult'#4^#](x1, x2, x3) = [1] x1 + [1] x3 + [2] [dequeue#1^#](x1, x2) = [1] x2 + [1] [bftMult'#5^#](x1, x2, x3) = [1] x1 + [1] x3 + [1] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [0] [matrixMult#1^#](x1, x2) = [0] [computeLine^#](x1, x2, x3) = [0] [computeLine#1^#](x1, x2, x3) = [0] [computeLine#2^#](x1, x2, x3, x4) = [0] [lineMult^#](x1, x2, x3) = [0] [lineMult#1^#](x1, x2, x3) = [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [1] x1 + [1] [lineMult#2^#](x1, x2, x3, x4) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1, x2) = [2] x1 + [1] x2 + [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1, x2) = [1] x1 + [1] x2 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1) = [1] x1 + [0] [c_21](x1) = [1] x1 + [0] This order satisfies following ordering constraints [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [1] >= [1] @a + [1] @as + [1] @sofar + [1] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bftMult'#2(tuple#2(@dequeue@1, @dequeue@2))] = [1] @dequeue@1 + [1] @dequeue@2 + [2] >= [1] @dequeue@1 + [1] @dequeue@2 + [2] = [dequeue(@dequeue@1, @dequeue@2)] [dequeue(@outq, @inq)] = [1] @inq + [1] @outq + [2] >= [1] @inq + [1] @outq + [2] = [dequeue#1(@outq, @inq)] [enqueue(@t, @queue)] = [1] @queue + [1] @t + [1] >= [1] @queue + [1] @t + [1] = [enqueue#1(@queue, @t)] [dequeue#1(::(@t, @ts), @inq)] = [1] @inq + [1] @t + [1] @ts + [3] >= [1] @inq + [1] @t + [1] @ts + [3] = [tuple#2(::(@t, nil()), tuple#2(@ts, @inq))] [dequeue#1(nil(), @inq)] = [1] @inq + [2] >= [1] @inq + [2] = [dequeue#2(reverse(@inq))] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [dequeue#2(::(@t, @ts))] = [1] @t + [1] @ts + [3] >= [1] @t + [1] @ts + [3] = [tuple#2(::(@t, nil()), tuple#2(@ts, nil()))] [dequeue#2(nil())] = [2] >= [2] = [tuple#2(nil(), tuple#2(nil(), nil()))] [enqueue#1(tuple#2(@outq, @inq), @t)] = [1] @inq + [1] @outq + [1] @t + [2] >= [1] @inq + [1] @outq + [1] @t + [2] = [tuple#2(@outq, ::(@t, @inq))] [appendreverse^#(@toreverse, @sofar)] = [1] @toreverse + [1] > [1] @toreverse + [0] = [c_1(appendreverse#1^#(@toreverse, @sofar))] [appendreverse#1^#(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] >= [1] @as + [1] = [c_2(appendreverse^#(@as, ::(@a, @sofar)))] [bftMult'^#(@queue, @acc)] = [1] @queue + [1] >= [1] @queue + [1] = [bftMult'#1^#(bftMult'#2(@queue), @acc)] [bftMult'^#(@queue, @acc)] = [1] @queue + [1] >= [1] @queue + [1] = [bftMult'#2^#(@queue)] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [1] @elem + [1] @queue + [1] >= [1] @elem + [1] @queue + [1] = [bftMult'#3^#(@elem, @acc, @queue)] [bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2))] = [1] @dequeue@1 + [1] @dequeue@2 + [2] >= [1] @dequeue@2 + [2] = [c_5(dequeue^#(@dequeue@1, @dequeue@2))] [dequeue^#(@outq, @inq)] = [1] @inq + [2] > [1] @inq + [1] = [c_6(dequeue#1^#(@outq, @inq))] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [1] @_@3 + [1] @queue + [1] @t + [2] >= [1] @queue + [1] @t + [2] = [bftMult'#4^#(@t, @acc, @queue)] [bftMult'#4^#(leaf(), @acc, @queue)] = [1] @queue + [2] > [1] @queue + [1] = [bftMult'^#(@queue, @acc)] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [3] >= [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [3] = [bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)] [dequeue#1^#(nil(), @inq)] = [1] @inq + [1] >= [1] @inq + [1] = [c_10(reverse^#(@inq))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [1] @y + [1] >= [1] @queue' + [1] = [bftMult'^#(@queue', matrixMult(@acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [1] @y + [1] > [0] = [matrixMult^#(@acc, @y)] [matrixMult^#(@m1, @m2)] = [0] >= [0] = [c_12(matrixMult#1^#(@m1, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [0] >= [0] = [c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2))] [computeLine^#(@line, @m, @acc)] = [0] >= [0] = [c_14(computeLine#1^#(@line, @acc, @m))] [computeLine#1^#(::(@x, @xs), @acc, @m)] = [0] >= [0] = [c_15(computeLine#2^#(@m, @acc, @x, @xs))] [computeLine#2^#(::(@l, @ls), @acc, @x, @xs)] = [0] >= [0] = [c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc))] [lineMult^#(@n, @l1, @l2)] = [0] >= [0] = [c_17(lineMult#1^#(@l1, @l2, @n))] [lineMult#1^#(::(@x, @xs), @l2, @n)] = [0] >= [0] = [c_18(lineMult#2^#(@l2, @n, @x, @xs))] [reverse^#(@xs)] = [1] @xs + [1] >= [1] @xs + [1] = [c_19(appendreverse^#(@xs, nil()))] [lineMult#2^#(::(@y, @ys), @n, @x, @xs)] = [0] >= [0] = [c_20(lineMult^#(@n, @xs, @ys))] [lineMult#2^#(nil(), @n, @x, @xs)] = [0] >= [0] = [c_21(lineMult^#(@n, @xs, nil()))] Consider the set of all dependency pairs DPs: { 1: appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , 2: bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) , 3: dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , 4: dequeue#1^#(nil(), @inq) -> c_10(reverse^#(@inq)) , 5: matrixMult^#(@m1, @m2) -> c_12(matrixMult#1^#(@m1, @m2)) , 6: matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , 7: computeLine^#(@line, @m, @acc) -> c_14(computeLine#1^#(@line, @acc, @m)) , 8: computeLine#1^#(::(@x, @xs), @acc, @m) -> c_15(computeLine#2^#(@m, @acc, @x, @xs)) , 9: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , 10: lineMult^#(@n, @l1, @l2) -> c_17(lineMult#1^#(@l1, @l2, @n)) , 11: lineMult#1^#(::(@x, @xs), @l2, @n) -> c_18(lineMult#2^#(@l2, @n, @x, @xs)) , 12: reverse^#(@xs) -> c_19(appendreverse^#(@xs, nil())) , 13: lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_20(lineMult^#(@n, @xs, @ys)) , 14: lineMult#2^#(nil(), @n, @x, @xs) -> c_21(lineMult^#(@n, @xs, nil())) , 15: appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , 16: bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , 17: bftMult'^#(@queue, @acc) -> bftMult'#2^#(@queue) , 18: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , 19: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , 20: bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , 21: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , 22: bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , 23: bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {1,3,20,23}. These cover all (indirect) predecessors of dependency pairs {1,3,4,12,15,20,23}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_14(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_15(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_17(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_18(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_20(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_21(lineMult^#(@n, @xs, nil())) } Weak DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'^#(@queue, @acc) -> bftMult'#2^#(@queue) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , dequeue#1^#(nil(), @inq) -> c_10(reverse^#(@inq)) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) , reverse^#(@xs) -> c_19(appendreverse^#(@xs, nil())) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , dequeue^#(@outq, @inq) -> c_6(dequeue#1^#(@outq, @inq)) , dequeue#1^#(nil(), @inq) -> c_10(reverse^#(@inq)) , reverse^#(@xs) -> c_19(appendreverse^#(@xs, nil())) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) , matrixMult^#(@m1, @m2) -> c_12(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_14(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_15(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_16(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_17(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_18(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_20(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_21(lineMult^#(@n, @xs, nil())) } Weak DPs: { bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'^#(@queue, @acc) -> bftMult'#2^#(@queue) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_5(dequeue^#(@dequeue@1, @dequeue@2)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_1() , matrixMult^#(@m1, @m2) -> c_2(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_3(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) } Weak DPs: { bftMult'^#(@queue, @acc) -> c_11(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'^#(@queue, @acc) -> c_12(bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_13(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_14(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_15(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_16(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_17(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_18(matrixMult^#(@acc, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 12: bftMult'^#(@queue, @acc) -> c_12(bftMult'#2^#(@queue)) , 18: bftMult'#5^#(@queue', @acc, @y) -> c_18(matrixMult^#(@acc, @y)) } Trs: { appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , lineMult#1(nil(), @l2, @n) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_2) = {1}, Uargs(c_3) = {1, 2}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [0] [#add](x1, x2) = [1] x2 + [0] [appendreverse](x1, x2) = [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [nil] = [1] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [0] [bftMult'#2](x1) = [1] x1 + [1] [dequeue](x1, x2) = [0] [leaf] = [0] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [enqueue](x1, x2) = [0] [matrixMult](x1, x2) = [0] [computeLine](x1, x2, x3) = [0] [computeLine#1](x1, x2, x3) = [1] x2 + [1] [computeLine#2](x1, x2, x3, x4) = [1] [lineMult](x1, x2, x3) = [0] [dequeue#1](x1, x2) = [1] x1 + [1] x2 + [0] [reverse](x1) = [0] [dequeue#2](x1) = [1] x1 + [0] [enqueue#1](x1, x2) = [1] x1 + [1] [lineMult#1](x1, x2, x3) = [1] x1 + [1] [lineMult#2](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0] [matrixMult#1](x1, x2) = [0] [#0] = [0] [#s](x1) = [0] [#neg](x1) = [0] [#pred](x1) = [0] [#pos](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [1] [bftMult'#1^#](x1, x2) = [1] [bftMult'#2^#](x1) = [0] [dequeue^#](x1, x2) = [0] [bftMult'#3^#](x1, x2, x3) = [1] [bftMult'#4^#](x1, x2, x3) = [1] [dequeue#1^#](x1, x2) = [0] [bftMult'#5^#](x1, x2, x3) = [1] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [0] [matrixMult#1^#](x1, x2) = [0] [computeLine^#](x1, x2, x3) = [0] [computeLine#1^#](x1, x2, x3) = [0] [computeLine#2^#](x1, x2, x3, x4) = [0] [lineMult^#](x1, x2, x3) = [0] [lineMult#1^#](x1, x2, x3) = [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [0] [lineMult#2^#](x1, x2, x3, x4) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_1](x1) = [0] [c_2](x1) = [0] [c_5](x1) = [0] [c_6](x1) = [0] [c_10](x1) = [0] [c_12](x1) = [0] [c_13](x1, x2) = [0] [c_14](x1) = [0] [c_15](x1) = [0] [c_16](x1, x2) = [0] [c_17](x1) = [0] [c_18](x1) = [0] [c_19](x1) = [0] [c_20](x1) = [0] [c_21](x1) = [0] [c] = [0] [c_1] = [0] [c_2](x1) = [1] x1 + [0] [c_3](x1, x2) = [1] x1 + [1] x2 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1, x2) = [1] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1) = [1] x1 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] This order satisfies following ordering constraints [bftMult'^#(@queue, @acc)] = [1] >= [1] = [c_11(bftMult'#1^#(bftMult'#2(@queue), @acc))] [bftMult'^#(@queue, @acc)] = [1] > [0] = [c_12(bftMult'#2^#(@queue))] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [1] >= [1] = [c_13(bftMult'#3^#(@elem, @acc, @queue))] [bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2))] = [0] >= [0] = [c_1()] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [1] >= [1] = [c_14(bftMult'#4^#(@t, @acc, @queue))] [bftMult'#4^#(leaf(), @acc, @queue)] = [1] >= [1] = [c_15(bftMult'^#(@queue, @acc))] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [1] >= [1] = [c_16(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [1] >= [1] = [c_17(bftMult'^#(@queue', matrixMult(@acc, @y)))] [bftMult'#5^#(@queue', @acc, @y)] = [1] > [0] = [c_18(matrixMult^#(@acc, @y))] [matrixMult^#(@m1, @m2)] = [0] >= [0] = [c_2(matrixMult#1^#(@m1, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [0] >= [0] = [c_3(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2))] [computeLine^#(@line, @m, @acc)] = [0] >= [0] = [c_4(computeLine#1^#(@line, @acc, @m))] [computeLine#1^#(::(@x, @xs), @acc, @m)] = [0] >= [0] = [c_5(computeLine#2^#(@m, @acc, @x, @xs))] [computeLine#2^#(::(@l, @ls), @acc, @x, @xs)] = [0] >= [0] = [c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc))] [lineMult^#(@n, @l1, @l2)] = [0] >= [0] = [c_7(lineMult#1^#(@l1, @l2, @n))] [lineMult#1^#(::(@x, @xs), @l2, @n)] = [0] >= [0] = [c_8(lineMult#2^#(@l2, @n, @x, @xs))] [lineMult#2^#(::(@y, @ys), @n, @x, @xs)] = [0] >= [0] = [c_9(lineMult^#(@n, @xs, @ys))] [lineMult#2^#(nil(), @n, @x, @xs)] = [0] >= [0] = [c_10(lineMult^#(@n, @xs, nil()))] Consider the set of all dependency pairs DPs: { 1: bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_1() , 2: matrixMult^#(@m1, @m2) -> c_2(matrixMult#1^#(@m1, @m2)) , 3: matrixMult#1^#(::(@l, @ls), @m2) -> c_3(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , 4: computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , 5: computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , 6: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , 7: lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , 8: lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , 9: lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , 10: lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) , 11: bftMult'^#(@queue, @acc) -> c_11(bftMult'#1^#(bftMult'#2(@queue), @acc)) , 12: bftMult'^#(@queue, @acc) -> c_12(bftMult'#2^#(@queue)) , 13: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_13(bftMult'#3^#(@elem, @acc, @queue)) , 14: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_14(bftMult'#4^#(@t, @acc, @queue)) , 15: bftMult'#4^#(leaf(), @acc, @queue) -> c_15(bftMult'^#(@queue, @acc)) , 16: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_16(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , 17: bftMult'#5^#(@queue', @acc, @y) -> c_17(bftMult'^#(@queue', matrixMult(@acc, @y))) , 18: bftMult'#5^#(@queue', @acc, @y) -> c_18(matrixMult^#(@acc, @y)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {12,18}. These cover all (indirect) predecessors of dependency pairs {1,12,18}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { matrixMult^#(@m1, @m2) -> c_2(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_3(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) } Weak DPs: { bftMult'^#(@queue, @acc) -> c_11(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'^#(@queue, @acc) -> c_12(bftMult'#2^#(@queue)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_13(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_1() , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_14(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_15(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_16(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_17(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_18(matrixMult^#(@acc, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bftMult'^#(@queue, @acc) -> c_12(bftMult'#2^#(@queue)) , bftMult'#2^#(tuple#2(@dequeue@1, @dequeue@2)) -> c_1() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { matrixMult^#(@m1, @m2) -> c_2(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_3(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) , computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) } Weak DPs: { bftMult'^#(@queue, @acc) -> c_11(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_13(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_14(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_15(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_16(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_17(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_18(matrixMult^#(@acc, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We decompose the input problem according to the dependency graph into the upper component { bftMult'^#(@queue, @acc) -> c_11(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_13(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_14(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_15(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_16(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_17(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_18(matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_2(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_3(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) } and lower component { computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) } Further, following extension rules are added to the lower component. { bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) , matrixMult^#(@m1, @m2) -> matrixMult#1^#(@m1, @m2) , matrixMult#1^#(::(@l, @ls), @m2) -> matrixMult^#(@ls, @m2) , matrixMult#1^#(::(@l, @ls), @m2) -> computeLine^#(@l, @m2, nil()) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult^#(@m1, @m2) -> c_2(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_3(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) } Weak DPs: { bftMult'^#(@queue, @acc) -> c_11(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_13(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_14(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_15(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_16(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_17(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_18(matrixMult^#(@acc, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMult#1^#(::(@l, @ls), @m2) -> c_3(computeLine^#(@l, @m2, nil()), matrixMult^#(@ls, @m2)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult^#(@m1, @m2) -> c_1(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_2(matrixMult^#(@ls, @m2)) } Weak DPs: { bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_5(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_6(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_7(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_8(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_9(matrixMult^#(@acc, @y)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 2: matrixMult#1^#(::(@l, @ls), @m2) -> c_2(matrixMult^#(@ls, @m2)) } Trs: { #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x1 + [1] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse](x1, x2) = [0] [appendreverse#1](x1, x2) = [1] x2 + [1] [::](x1, x2) = [1] x2 + [1] [nil] = [1] [tuple#2](x1, x2) = [1] [bftMult'#2](x1) = [0] [dequeue](x1, x2) = [0] [leaf] = [0] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [enqueue](x1, x2) = [0] [matrixMult](x1, x2) = [1] x1 + [0] [computeLine](x1, x2, x3) = [0] [computeLine#1](x1, x2, x3) = [1] x1 + [1] x2 + [0] [computeLine#2](x1, x2, x3, x4) = [1] x1 + [0] [lineMult](x1, x2, x3) = [0] [dequeue#1](x1, x2) = [1] x2 + [0] [reverse](x1) = [0] [dequeue#2](x1) = [0] [enqueue#1](x1, x2) = [1] x1 + [1] [lineMult#1](x1, x2, x3) = [1] x1 + [1] [lineMult#2](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMult#1](x1, x2) = [1] x1 + [0] [#0] = [1] [#s](x1) = [0] [#neg](x1) = [0] [#pred](x1) = [0] [#pos](x1) = [1] [#succ](x1) = [0] [#natmult](x1, x2) = [1] [#natadd](x1, x2) = [1] x2 + [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [1] x2 + [0] [bftMult'#1^#](x1, x2) = [1] x2 + [0] [bftMult'#2^#](x1) = [0] [dequeue^#](x1, x2) = [0] [bftMult'#3^#](x1, x2, x3) = [1] x2 + [0] [bftMult'#4^#](x1, x2, x3) = [1] x2 + [0] [dequeue#1^#](x1, x2) = [0] [bftMult'#5^#](x1, x2, x3) = [1] x2 + [0] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [1] x1 + [0] [matrixMult#1^#](x1, x2) = [1] x1 + [0] [computeLine^#](x1, x2, x3) = [0] [computeLine#1^#](x1, x2, x3) = [0] [computeLine#2^#](x1, x2, x3, x4) = [0] [lineMult^#](x1, x2, x3) = [0] [lineMult#1^#](x1, x2, x3) = [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [0] [lineMult#2^#](x1, x2, x3, x4) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_2](x1) = [0] [c_3](x1, x2) = [0] [c_11](x1) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1) = [0] [c_16](x1) = [0] [c_17](x1) = [0] [c_18](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] This order satisfies following ordering constraints [matrixMult(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [matrixMult#1(@m1, @m2)] [matrixMult#1(::(@l, @ls), @m2)] = [1] @ls + [1] >= [1] @ls + [1] = [::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2))] [matrixMult#1(nil(), @m2)] = [1] >= [1] = [nil()] [#natmult(#0(), @y)] = [1] >= [1] = [#0()] [#natmult(#s(@x), @y)] = [1] >= [1] = [#natadd(@y, #natmult(@x, @y))] [#natadd(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#natadd(#s(@x), @y)] = [1] @y + [0] >= [0] = [#s(#natadd(@x, @y))] [bftMult'^#(@queue, @acc)] = [1] @acc + [0] >= [1] @acc + [0] = [c_3(bftMult'#1^#(bftMult'#2(@queue), @acc))] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [1] @acc + [0] >= [1] @acc + [0] = [c_4(bftMult'#3^#(@elem, @acc, @queue))] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [1] @acc + [0] >= [1] @acc + [0] = [c_5(bftMult'#4^#(@t, @acc, @queue))] [bftMult'#4^#(leaf(), @acc, @queue)] = [1] @acc + [0] >= [1] @acc + [0] = [c_6(bftMult'^#(@queue, @acc))] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [1] @acc + [0] >= [1] @acc + [0] = [c_7(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @acc + [0] >= [1] @acc + [0] = [c_8(bftMult'^#(@queue', matrixMult(@acc, @y)))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @acc + [0] >= [1] @acc + [0] = [c_9(matrixMult^#(@acc, @y))] [matrixMult^#(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [c_1(matrixMult#1^#(@m1, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [1] @ls + [1] > [1] @ls + [0] = [c_2(matrixMult^#(@ls, @m2))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult^#(@m1, @m2) -> c_1(matrixMult#1^#(@m1, @m2)) } Weak DPs: { bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_5(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_6(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_7(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_8(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_9(matrixMult^#(@acc, @y)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_2(matrixMult^#(@ls, @m2)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 8: bftMult'#5^#(@queue', @acc, @y) -> c_9(matrixMult^#(@acc, @y)) , 9: matrixMult#1^#(::(@l, @ls), @m2) -> c_2(matrixMult^#(@ls, @m2)) } Trs: { appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(nil(), @l2, @n) -> nil() , #pred(#0()) -> #neg(#s(#0())) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x1 + [0] [#add](x1, x2) = [1] x2 + [0] [appendreverse](x1, x2) = [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [nil] = [0] [tuple#2](x1, x2) = [1] x1 + [0] [bftMult'#2](x1) = [1] [dequeue](x1, x2) = [0] [leaf] = [0] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [enqueue](x1, x2) = [1] x2 + [1] [matrixMult](x1, x2) = [1] x1 + [0] [computeLine](x1, x2, x3) = [1] x3 + [0] [computeLine#1](x1, x2, x3) = [1] x2 + [0] [computeLine#2](x1, x2, x3, x4) = [1] x1 + [0] [lineMult](x1, x2, x3) = [0] [dequeue#1](x1, x2) = [1] x2 + [0] [reverse](x1) = [0] [dequeue#2](x1) = [0] [enqueue#1](x1, x2) = [1] x1 + [1] [lineMult#1](x1, x2, x3) = [1] x1 + [1] [lineMult#2](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] [matrixMult#1](x1, x2) = [1] x1 + [0] [#0] = [1] [#s](x1) = [1] [#neg](x1) = [0] [#pred](x1) = [1] x1 + [0] [#pos](x1) = [1] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [1] x1 + [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [1] x2 + [1] [bftMult'#1^#](x1, x2) = [1] x2 + [1] [bftMult'#2^#](x1) = [0] [dequeue^#](x1, x2) = [0] [bftMult'#3^#](x1, x2, x3) = [1] x2 + [1] [bftMult'#4^#](x1, x2, x3) = [1] x2 + [1] [dequeue#1^#](x1, x2) = [0] [bftMult'#5^#](x1, x2, x3) = [1] x2 + [1] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [1] x1 + [0] [matrixMult#1^#](x1, x2) = [1] x1 + [0] [computeLine^#](x1, x2, x3) = [0] [computeLine#1^#](x1, x2, x3) = [0] [computeLine#2^#](x1, x2, x3, x4) = [0] [lineMult^#](x1, x2, x3) = [0] [lineMult#1^#](x1, x2, x3) = [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [0] [lineMult#2^#](x1, x2, x3, x4) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_2](x1) = [0] [c_3](x1, x2) = [0] [c_11](x1) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1) = [0] [c_16](x1) = [0] [c_17](x1) = [0] [c_18](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] This order satisfies following ordering constraints [matrixMult(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [matrixMult#1(@m1, @m2)] [matrixMult#1(::(@l, @ls), @m2)] = [1] @ls + [1] >= [1] @ls + [1] = [::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2))] [matrixMult#1(nil(), @m2)] = [0] >= [0] = [nil()] [bftMult'^#(@queue, @acc)] = [1] @acc + [1] >= [1] @acc + [1] = [c_3(bftMult'#1^#(bftMult'#2(@queue), @acc))] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [1] @acc + [1] >= [1] @acc + [1] = [c_4(bftMult'#3^#(@elem, @acc, @queue))] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [1] @acc + [1] >= [1] @acc + [1] = [c_5(bftMult'#4^#(@t, @acc, @queue))] [bftMult'#4^#(leaf(), @acc, @queue)] = [1] @acc + [1] >= [1] @acc + [1] = [c_6(bftMult'^#(@queue, @acc))] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [1] @acc + [1] >= [1] @acc + [1] = [c_7(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @acc + [1] >= [1] @acc + [1] = [c_8(bftMult'^#(@queue', matrixMult(@acc, @y)))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @acc + [1] > [1] @acc + [0] = [c_9(matrixMult^#(@acc, @y))] [matrixMult^#(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [c_1(matrixMult#1^#(@m1, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [1] @ls + [1] > [1] @ls + [0] = [c_2(matrixMult^#(@ls, @m2))] Consider the set of all dependency pairs DPs: { 1: matrixMult^#(@m1, @m2) -> c_1(matrixMult#1^#(@m1, @m2)) , 2: bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc)) , 3: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , 4: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_5(bftMult'#4^#(@t, @acc, @queue)) , 5: bftMult'#4^#(leaf(), @acc, @queue) -> c_6(bftMult'^#(@queue, @acc)) , 6: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_7(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , 7: bftMult'#5^#(@queue', @acc, @y) -> c_8(bftMult'^#(@queue', matrixMult(@acc, @y))) , 8: bftMult'#5^#(@queue', @acc, @y) -> c_9(matrixMult^#(@acc, @y)) , 9: matrixMult#1^#(::(@l, @ls), @m2) -> c_2(matrixMult^#(@ls, @m2)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {8,9}. These cover all (indirect) predecessors of dependency pairs {1,8,9}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_5(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_6(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_7(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_8(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_9(matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_1(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_2(matrixMult^#(@ls, @m2)) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bftMult'^#(@queue, @acc) -> c_3(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_4(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_5(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_6(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_7(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_8(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_9(matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_1(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_2(matrixMult^#(@ls, @m2)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) } Weak DPs: { bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) , matrixMult^#(@m1, @m2) -> matrixMult#1^#(@m1, @m2) , matrixMult#1^#(::(@l, @ls), @m2) -> matrixMult^#(@ls, @m2) , matrixMult#1^#(::(@l, @ls), @m2) -> computeLine^#(@l, @m2, nil()) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 4: lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , 11: bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) } Trs: { computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x2 + [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [nil] = [0] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [0] [bftMult'#2](x1) = [1] x1 + [0] [dequeue](x1, x2) = [1] x1 + [1] x2 + [0] [leaf] = [0] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [enqueue](x1, x2) = [1] x1 + [1] x2 + [1] [matrixMult](x1, x2) = [0] [computeLine](x1, x2, x3) = [0] [computeLine#1](x1, x2, x3) = [1] x1 + [1] x2 + [0] [computeLine#2](x1, x2, x3, x4) = [1] [lineMult](x1, x2, x3) = [1] x2 + [1] x3 + [0] [dequeue#1](x1, x2) = [1] x1 + [1] x2 + [0] [reverse](x1) = [1] x1 + [0] [dequeue#2](x1) = [1] x1 + [0] [enqueue#1](x1, x2) = [1] x1 + [1] x2 + [1] [lineMult#1](x1, x2, x3) = [1] x1 + [1] x2 + [0] [lineMult#2](x1, x2, x3, x4) = [1] x1 + [1] x4 + [1] [matrixMult#1](x1, x2) = [1] x1 + [0] [#0] = [0] [#s](x1) = [0] [#neg](x1) = [0] [#pred](x1) = [0] [#pos](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [1] x1 + [0] [bftMult'#1^#](x1, x2) = [1] x1 + [0] [bftMult'#2^#](x1) = [0] [dequeue^#](x1, x2) = [0] [bftMult'#3^#](x1, x2, x3) = [1] x1 + [1] x3 + [0] [bftMult'#4^#](x1, x2, x3) = [1] x1 + [1] x3 + [1] [dequeue#1^#](x1, x2) = [0] [bftMult'#5^#](x1, x2, x3) = [1] x1 + [1] x3 + [0] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [1] x2 + [0] [matrixMult#1^#](x1, x2) = [1] x2 + [0] [computeLine^#](x1, x2, x3) = [1] x2 + [0] [computeLine#1^#](x1, x2, x3) = [1] x3 + [0] [computeLine#2^#](x1, x2, x3, x4) = [1] x1 + [0] [lineMult^#](x1, x2, x3) = [1] x2 + [1] [lineMult#1^#](x1, x2, x3) = [1] x1 + [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [0] [lineMult#2^#](x1, x2, x3, x4) = [1] x4 + [1] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1, x2) = [1] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] This order satisfies following ordering constraints [*(@x, @y)] = [0] >= [0] = [#mult(@x, @y)] [#mult(#0(), #0())] = [0] >= [0] = [#0()] [#mult(#0(), #neg(@y))] = [0] >= [0] = [#0()] [#mult(#0(), #pos(@y))] = [0] >= [0] = [#0()] [#mult(#neg(@x), #0())] = [0] >= [0] = [#0()] [#mult(#neg(@x), #neg(@y))] = [0] >= [0] = [#pos(#natmult(@x, @y))] [#mult(#neg(@x), #pos(@y))] = [0] >= [0] = [#neg(#natmult(@x, @y))] [#mult(#pos(@x), #0())] = [0] >= [0] = [#0()] [#mult(#pos(@x), #neg(@y))] = [0] >= [0] = [#neg(#natmult(@x, @y))] [#mult(#pos(@x), #pos(@y))] = [0] >= [0] = [#pos(#natmult(@x, @y))] [+(@x, @y)] = [1] @y + [0] >= [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#pred(#add(#pos(#s(@x)), @y))] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#succ(#add(#pos(#s(@x)), @y))] [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [1] >= [1] @a + [1] @as + [1] @sofar + [1] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bftMult'#2(tuple#2(@dequeue@1, @dequeue@2))] = [1] @dequeue@1 + [1] @dequeue@2 + [0] >= [1] @dequeue@1 + [1] @dequeue@2 + [0] = [dequeue(@dequeue@1, @dequeue@2)] [dequeue(@outq, @inq)] = [1] @inq + [1] @outq + [0] >= [1] @inq + [1] @outq + [0] = [dequeue#1(@outq, @inq)] [enqueue(@t, @queue)] = [1] @queue + [1] @t + [1] >= [1] @queue + [1] @t + [1] = [enqueue#1(@queue, @t)] [lineMult(@n, @l1, @l2)] = [1] @l1 + [1] @l2 + [0] >= [1] @l1 + [1] @l2 + [0] = [lineMult#1(@l1, @l2, @n)] [dequeue#1(::(@t, @ts), @inq)] = [1] @inq + [1] @t + [1] @ts + [1] >= [1] @inq + [1] @t + [1] @ts + [1] = [tuple#2(::(@t, nil()), tuple#2(@ts, @inq))] [dequeue#1(nil(), @inq)] = [1] @inq + [0] >= [1] @inq + [0] = [dequeue#2(reverse(@inq))] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [dequeue#2(::(@t, @ts))] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [tuple#2(::(@t, nil()), tuple#2(@ts, nil()))] [dequeue#2(nil())] = [0] >= [0] = [tuple#2(nil(), tuple#2(nil(), nil()))] [enqueue#1(tuple#2(@outq, @inq), @t)] = [1] @inq + [1] @outq + [1] @t + [1] >= [1] @inq + [1] @outq + [1] @t + [1] = [tuple#2(@outq, ::(@t, @inq))] [lineMult#1(::(@x, @xs), @l2, @n)] = [1] @l2 + [1] @x + [1] @xs + [1] >= [1] @l2 + [1] @xs + [1] = [lineMult#2(@l2, @n, @x, @xs)] [lineMult#1(nil(), @l2, @n)] = [1] @l2 + [0] >= [0] = [nil()] [lineMult#2(::(@y, @ys), @n, @x, @xs)] = [1] @xs + [1] @y + [1] @ys + [2] > [1] @xs + [1] @y + [1] @ys + [1] = [::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys))] [lineMult#2(nil(), @n, @x, @xs)] = [1] @xs + [1] >= [1] @xs + [1] = [::(*(@x, @n), lineMult(@n, @xs, nil()))] [#pred(#0())] = [0] >= [0] = [#neg(#s(#0()))] [#pred(#neg(#s(@x)))] = [0] >= [0] = [#neg(#s(#s(@x)))] [#pred(#pos(#s(#0())))] = [0] >= [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0] >= [0] = [#pos(#s(@x))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#neg(#s(#0())))] = [0] >= [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0] >= [0] = [#neg(#s(@x))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [bftMult'^#(@queue, @acc)] = [1] @queue + [0] >= [1] @queue + [0] = [bftMult'#1^#(bftMult'#2(@queue), @acc)] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [1] @elem + [1] @queue + [0] >= [1] @elem + [1] @queue + [0] = [bftMult'#3^#(@elem, @acc, @queue)] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [1] @_@3 + [1] @queue + [1] @t + [1] >= [1] @queue + [1] @t + [1] = [bftMult'#4^#(@t, @acc, @queue)] [bftMult'#4^#(leaf(), @acc, @queue)] = [1] @queue + [1] > [1] @queue + [0] = [bftMult'^#(@queue, @acc)] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [2] >= [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [2] = [bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [1] @y + [0] >= [1] @queue' + [0] = [bftMult'^#(@queue', matrixMult(@acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [1] @y + [0] >= [1] @y + [0] = [matrixMult^#(@acc, @y)] [matrixMult^#(@m1, @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [matrixMult#1^#(@m1, @m2)] [matrixMult#1^#(::(@l, @ls), @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [matrixMult^#(@ls, @m2)] [matrixMult#1^#(::(@l, @ls), @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [computeLine^#(@l, @m2, nil())] [computeLine^#(@line, @m, @acc)] = [1] @m + [0] >= [1] @m + [0] = [c_4(computeLine#1^#(@line, @acc, @m))] [computeLine#1^#(::(@x, @xs), @acc, @m)] = [1] @m + [0] >= [1] @m + [0] = [c_5(computeLine#2^#(@m, @acc, @x, @xs))] [computeLine#2^#(::(@l, @ls), @acc, @x, @xs)] = [1] @l + [1] @ls + [1] >= [1] @l + [1] @ls + [1] = [c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc))] [lineMult^#(@n, @l1, @l2)] = [1] @l1 + [1] > [1] @l1 + [0] = [c_7(lineMult#1^#(@l1, @l2, @n))] [lineMult#1^#(::(@x, @xs), @l2, @n)] = [1] @x + [1] @xs + [1] >= [1] @xs + [1] = [c_8(lineMult#2^#(@l2, @n, @x, @xs))] [lineMult#2^#(::(@y, @ys), @n, @x, @xs)] = [1] @xs + [1] >= [1] @xs + [1] = [c_9(lineMult^#(@n, @xs, @ys))] [lineMult#2^#(nil(), @n, @x, @xs)] = [1] @xs + [1] >= [1] @xs + [1] = [c_10(lineMult^#(@n, @xs, nil()))] Consider the set of all dependency pairs DPs: { 1: computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , 2: computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , 3: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) , 4: lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , 5: lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , 6: lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , 7: lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) , 8: bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , 9: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , 10: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , 11: bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , 12: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , 13: bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , 14: bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) , 15: matrixMult^#(@m1, @m2) -> matrixMult#1^#(@m1, @m2) , 16: matrixMult#1^#(::(@l, @ls), @m2) -> matrixMult^#(@ls, @m2) , 17: matrixMult#1^#(::(@l, @ls), @m2) -> computeLine^#(@l, @m2, nil()) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {4,11}. These cover all (indirect) predecessors of dependency pairs {4,5,6,7,11}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) } Weak DPs: { bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) , matrixMult^#(@m1, @m2) -> matrixMult#1^#(@m1, @m2) , matrixMult#1^#(::(@l, @ls), @m2) -> matrixMult^#(@ls, @m2) , matrixMult#1^#(::(@l, @ls), @m2) -> computeLine^#(@l, @m2, nil()) , lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { lineMult^#(@n, @l1, @l2) -> c_7(lineMult#1^#(@l1, @l2, @n)) , lineMult#1^#(::(@x, @xs), @l2, @n) -> c_8(lineMult#2^#(@l2, @n, @x, @xs)) , lineMult#2^#(::(@y, @ys), @n, @x, @xs) -> c_9(lineMult^#(@n, @xs, @ys)) , lineMult#2^#(nil(), @n, @x, @xs) -> c_10(lineMult^#(@n, @xs, nil())) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { computeLine^#(@line, @m, @acc) -> c_4(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_5(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) } Weak DPs: { bftMult'^#(@queue, @acc) -> bftMult'#1^#(bftMult'#2(@queue), @acc) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> bftMult'#3^#(@elem, @acc, @queue) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> bftMult'#4^#(@t, @acc, @queue) , bftMult'#4^#(leaf(), @acc, @queue) -> bftMult'^#(@queue, @acc) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y) , bftMult'#5^#(@queue', @acc, @y) -> bftMult'^#(@queue', matrixMult(@acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> matrixMult^#(@acc, @y) , matrixMult^#(@m1, @m2) -> matrixMult#1^#(@m1, @m2) , matrixMult#1^#(::(@l, @ls), @m2) -> matrixMult^#(@ls, @m2) , matrixMult#1^#(::(@l, @ls), @m2) -> computeLine^#(@l, @m2, nil()) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_6(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)), lineMult^#(@x, @l, @acc)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { computeLine^#(@line, @m, @acc) -> c_1(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_2(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc))) } Weak DPs: { bftMult'^#(@queue, @acc) -> c_4(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_5(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_6(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_7(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_8(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_9(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_10(matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_11(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_12(matrixMult^#(@ls, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil())) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 3: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc))) , 7: bftMult'#4^#(leaf(), @acc, @queue) -> c_7(bftMult'^#(@queue, @acc)) } Trs: { computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult#1(nil(), @l2, @n) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [0] [#add](x1, x2) = [1] x2 + [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [nil] = [0] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [0] [bftMult'#2](x1) = [1] x1 + [0] [dequeue](x1, x2) = [1] x1 + [1] x2 + [0] [leaf] = [0] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [enqueue](x1, x2) = [1] x1 + [1] x2 + [1] [matrixMult](x1, x2) = [0] [computeLine](x1, x2, x3) = [0] [computeLine#1](x1, x2, x3) = [1] x1 + [1] x2 + [0] [computeLine#2](x1, x2, x3, x4) = [1] [lineMult](x1, x2, x3) = [0] [dequeue#1](x1, x2) = [1] x1 + [1] x2 + [0] [reverse](x1) = [1] x1 + [0] [dequeue#2](x1) = [1] x1 + [0] [enqueue#1](x1, x2) = [1] x1 + [1] x2 + [1] [lineMult#1](x1, x2, x3) = [1] [lineMult#2](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] [matrixMult#1](x1, x2) = [1] x1 + [0] [#0] = [0] [#s](x1) = [0] [#neg](x1) = [0] [#pred](x1) = [0] [#pos](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [1] x1 + [0] [bftMult'#1^#](x1, x2) = [1] x1 + [0] [bftMult'#2^#](x1) = [0] [dequeue^#](x1, x2) = [0] [bftMult'#3^#](x1, x2, x3) = [1] x1 + [1] x3 + [0] [bftMult'#4^#](x1, x2, x3) = [1] x1 + [1] x3 + [1] [dequeue#1^#](x1, x2) = [0] [bftMult'#5^#](x1, x2, x3) = [1] x1 + [1] x3 + [0] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [1] x2 + [0] [matrixMult#1^#](x1, x2) = [1] x2 + [0] [computeLine^#](x1, x2, x3) = [1] x2 + [0] [computeLine#1^#](x1, x2, x3) = [1] x3 + [0] [computeLine#2^#](x1, x2, x3, x4) = [1] x1 + [0] [lineMult^#](x1, x2, x3) = [0] [lineMult#1^#](x1, x2, x3) = [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [0] [lineMult#2^#](x1, x2, x3, x4) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_4](x1) = [0] [c_5](x1) = [0] [c_6](x1, x2) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1) = [1] x1 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] This order satisfies following ordering constraints [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [1] >= [1] @a + [1] @as + [1] @sofar + [1] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bftMult'#2(tuple#2(@dequeue@1, @dequeue@2))] = [1] @dequeue@1 + [1] @dequeue@2 + [0] >= [1] @dequeue@1 + [1] @dequeue@2 + [0] = [dequeue(@dequeue@1, @dequeue@2)] [dequeue(@outq, @inq)] = [1] @inq + [1] @outq + [0] >= [1] @inq + [1] @outq + [0] = [dequeue#1(@outq, @inq)] [enqueue(@t, @queue)] = [1] @queue + [1] @t + [1] >= [1] @queue + [1] @t + [1] = [enqueue#1(@queue, @t)] [dequeue#1(::(@t, @ts), @inq)] = [1] @inq + [1] @t + [1] @ts + [1] >= [1] @inq + [1] @t + [1] @ts + [1] = [tuple#2(::(@t, nil()), tuple#2(@ts, @inq))] [dequeue#1(nil(), @inq)] = [1] @inq + [0] >= [1] @inq + [0] = [dequeue#2(reverse(@inq))] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [dequeue#2(::(@t, @ts))] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [tuple#2(::(@t, nil()), tuple#2(@ts, nil()))] [dequeue#2(nil())] = [0] >= [0] = [tuple#2(nil(), tuple#2(nil(), nil()))] [enqueue#1(tuple#2(@outq, @inq), @t)] = [1] @inq + [1] @outq + [1] @t + [1] >= [1] @inq + [1] @outq + [1] @t + [1] = [tuple#2(@outq, ::(@t, @inq))] [bftMult'^#(@queue, @acc)] = [1] @queue + [0] >= [1] @queue + [0] = [c_4(bftMult'#1^#(bftMult'#2(@queue), @acc))] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [1] @elem + [1] @queue + [0] >= [1] @elem + [1] @queue + [0] = [c_5(bftMult'#3^#(@elem, @acc, @queue))] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [1] @_@3 + [1] @queue + [1] @t + [1] >= [1] @queue + [1] @t + [1] = [c_6(bftMult'#4^#(@t, @acc, @queue))] [bftMult'#4^#(leaf(), @acc, @queue)] = [1] @queue + [1] > [1] @queue + [0] = [c_7(bftMult'^#(@queue, @acc))] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [2] >= [1] @queue + [1] @t1 + [1] @t2 + [1] @y + [2] = [c_8(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [1] @y + [0] >= [1] @queue' + [0] = [c_9(bftMult'^#(@queue', matrixMult(@acc, @y)))] [bftMult'#5^#(@queue', @acc, @y)] = [1] @queue' + [1] @y + [0] >= [1] @y + [0] = [c_10(matrixMult^#(@acc, @y))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [c_11(matrixMult#1^#(@m1, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [c_12(matrixMult^#(@ls, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [c_13(computeLine^#(@l, @m2, nil()))] [computeLine^#(@line, @m, @acc)] = [1] @m + [0] >= [1] @m + [0] = [c_1(computeLine#1^#(@line, @acc, @m))] [computeLine#1^#(::(@x, @xs), @acc, @m)] = [1] @m + [0] >= [1] @m + [0] = [c_2(computeLine#2^#(@m, @acc, @x, @xs))] [computeLine#2^#(::(@l, @ls), @acc, @x, @xs)] = [1] @l + [1] @ls + [1] > [1] @ls + [0] = [c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { computeLine^#(@line, @m, @acc) -> c_1(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_2(computeLine#2^#(@m, @acc, @x, @xs)) } Weak DPs: { bftMult'^#(@queue, @acc) -> c_4(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_5(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_6(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_7(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_8(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_9(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_10(matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_11(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_12(matrixMult^#(@ls, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil())) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc))) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 12: matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil())) , 13: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc))) } Trs: { matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x2 + [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [nil] = [0] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [0] [bftMult'#2](x1) = [1] x1 + [1] [dequeue](x1, x2) = [1] x1 + [1] x2 + [1] [leaf] = [0] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [2] [enqueue](x1, x2) = [1] x1 + [1] x2 + [1] [matrixMult](x1, x2) = [2] x2 + [1] [computeLine](x1, x2, x3) = [1] x3 + [2] [computeLine#1](x1, x2, x3) = [2] x2 + [2] x3 + [0] [computeLine#2](x1, x2, x3, x4) = [2] [lineMult](x1, x2, x3) = [2] x2 + [1] x3 + [0] [dequeue#1](x1, x2) = [1] x1 + [1] x2 + [1] [reverse](x1) = [1] x1 + [0] [dequeue#2](x1) = [1] x1 + [0] [enqueue#1](x1, x2) = [1] x1 + [1] x2 + [1] [lineMult#1](x1, x2, x3) = [2] x1 + [1] x2 + [0] [lineMult#2](x1, x2, x3, x4) = [1] x1 + [2] x3 + [2] x4 + [2] [matrixMult#1](x1, x2) = [0] [#0] = [0] [#s](x1) = [0] [#neg](x1) = [0] [#pred](x1) = [0] [#pos](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bftMult^#](x1, x2) = [0] [bftMult'^#](x1, x2) = [2] x1 + [2] [bftMult'#1^#](x1, x2) = [2] x1 + [0] [bftMult'#2^#](x1) = [0] [dequeue^#](x1, x2) = [0] [bftMult'#3^#](x1, x2, x3) = [2] x1 + [2] x3 + [0] [bftMult'#4^#](x1, x2, x3) = [2] x1 + [2] x3 + [2] [dequeue#1^#](x1, x2) = [0] [bftMult'#5^#](x1, x2, x3) = [2] x1 + [1] x3 + [2] [enqueue^#](x1, x2) = [0] [enqueue#1^#](x1, x2) = [0] [matrixMult^#](x1, x2) = [1] x2 + [2] [matrixMult#1^#](x1, x2) = [1] x2 + [2] [computeLine^#](x1, x2, x3) = [1] x2 + [0] [computeLine#1^#](x1, x2, x3) = [1] x3 + [0] [computeLine#2^#](x1, x2, x3, x4) = [1] x1 + [0] [lineMult^#](x1, x2, x3) = [0] [lineMult#1^#](x1, x2, x3) = [0] [dequeue#2^#](x1) = [0] [reverse^#](x1) = [0] [lineMult#2^#](x1, x2, x3, x4) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_4](x1) = [0] [c_5](x1) = [0] [c_6](x1, x2) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1) = [1] x1 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] This order satisfies following ordering constraints [*(@x, @y)] = [0] >= [0] = [#mult(@x, @y)] [#mult(#0(), #0())] = [0] >= [0] = [#0()] [#mult(#0(), #neg(@y))] = [0] >= [0] = [#0()] [#mult(#0(), #pos(@y))] = [0] >= [0] = [#0()] [#mult(#neg(@x), #0())] = [0] >= [0] = [#0()] [#mult(#neg(@x), #neg(@y))] = [0] >= [0] = [#pos(#natmult(@x, @y))] [#mult(#neg(@x), #pos(@y))] = [0] >= [0] = [#neg(#natmult(@x, @y))] [#mult(#pos(@x), #0())] = [0] >= [0] = [#0()] [#mult(#pos(@x), #neg(@y))] = [0] >= [0] = [#neg(#natmult(@x, @y))] [#mult(#pos(@x), #pos(@y))] = [0] >= [0] = [#pos(#natmult(@x, @y))] [+(@x, @y)] = [1] @y + [0] >= [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#pred(#add(#pos(#s(@x)), @y))] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#succ(#add(#pos(#s(@x)), @y))] [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [1] >= [1] @a + [1] @as + [1] @sofar + [1] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bftMult'#2(tuple#2(@dequeue@1, @dequeue@2))] = [1] @dequeue@1 + [1] @dequeue@2 + [1] >= [1] @dequeue@1 + [1] @dequeue@2 + [1] = [dequeue(@dequeue@1, @dequeue@2)] [dequeue(@outq, @inq)] = [1] @inq + [1] @outq + [1] >= [1] @inq + [1] @outq + [1] = [dequeue#1(@outq, @inq)] [enqueue(@t, @queue)] = [1] @queue + [1] @t + [1] >= [1] @queue + [1] @t + [1] = [enqueue#1(@queue, @t)] [lineMult(@n, @l1, @l2)] = [2] @l1 + [1] @l2 + [0] >= [2] @l1 + [1] @l2 + [0] = [lineMult#1(@l1, @l2, @n)] [dequeue#1(::(@t, @ts), @inq)] = [1] @inq + [1] @t + [1] @ts + [2] > [1] @inq + [1] @t + [1] @ts + [1] = [tuple#2(::(@t, nil()), tuple#2(@ts, @inq))] [dequeue#1(nil(), @inq)] = [1] @inq + [1] > [1] @inq + [0] = [dequeue#2(reverse(@inq))] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [dequeue#2(::(@t, @ts))] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [tuple#2(::(@t, nil()), tuple#2(@ts, nil()))] [dequeue#2(nil())] = [0] >= [0] = [tuple#2(nil(), tuple#2(nil(), nil()))] [enqueue#1(tuple#2(@outq, @inq), @t)] = [1] @inq + [1] @outq + [1] @t + [1] >= [1] @inq + [1] @outq + [1] @t + [1] = [tuple#2(@outq, ::(@t, @inq))] [lineMult#1(::(@x, @xs), @l2, @n)] = [1] @l2 + [2] @x + [2] @xs + [2] >= [1] @l2 + [2] @x + [2] @xs + [2] = [lineMult#2(@l2, @n, @x, @xs)] [lineMult#1(nil(), @l2, @n)] = [1] @l2 + [0] >= [0] = [nil()] [lineMult#2(::(@y, @ys), @n, @x, @xs)] = [2] @x + [2] @xs + [1] @y + [1] @ys + [3] > [2] @xs + [1] @y + [1] @ys + [1] = [::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys))] [lineMult#2(nil(), @n, @x, @xs)] = [2] @x + [2] @xs + [2] > [2] @xs + [1] = [::(*(@x, @n), lineMult(@n, @xs, nil()))] [#pred(#0())] = [0] >= [0] = [#neg(#s(#0()))] [#pred(#neg(#s(@x)))] = [0] >= [0] = [#neg(#s(#s(@x)))] [#pred(#pos(#s(#0())))] = [0] >= [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0] >= [0] = [#pos(#s(@x))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#neg(#s(#0())))] = [0] >= [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0] >= [0] = [#neg(#s(@x))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [bftMult'^#(@queue, @acc)] = [2] @queue + [2] >= [2] @queue + [2] = [c_4(bftMult'#1^#(bftMult'#2(@queue), @acc))] [bftMult'#1^#(tuple#2(@elem, @queue), @acc)] = [2] @elem + [2] @queue + [0] >= [2] @elem + [2] @queue + [0] = [c_5(bftMult'#3^#(@elem, @acc, @queue))] [bftMult'#3^#(::(@t, @_@3), @acc, @queue)] = [2] @_@3 + [2] @queue + [2] @t + [2] >= [2] @queue + [2] @t + [2] = [c_6(bftMult'#4^#(@t, @acc, @queue))] [bftMult'#4^#(leaf(), @acc, @queue)] = [2] @queue + [2] >= [2] @queue + [2] = [c_7(bftMult'^#(@queue, @acc))] [bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue)] = [2] @queue + [2] @t1 + [2] @t2 + [2] @y + [6] >= [2] @queue + [2] @t1 + [2] @t2 + [1] @y + [6] = [c_8(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y))] [bftMult'#5^#(@queue', @acc, @y)] = [2] @queue' + [1] @y + [2] >= [2] @queue' + [2] = [c_9(bftMult'^#(@queue', matrixMult(@acc, @y)))] [bftMult'#5^#(@queue', @acc, @y)] = [2] @queue' + [1] @y + [2] >= [1] @y + [2] = [c_10(matrixMult^#(@acc, @y))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [2] >= [1] @m2 + [2] = [c_11(matrixMult#1^#(@m1, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [1] @m2 + [2] >= [1] @m2 + [2] = [c_12(matrixMult^#(@ls, @m2))] [matrixMult#1^#(::(@l, @ls), @m2)] = [1] @m2 + [2] > [1] @m2 + [0] = [c_13(computeLine^#(@l, @m2, nil()))] [computeLine^#(@line, @m, @acc)] = [1] @m + [0] >= [1] @m + [0] = [c_1(computeLine#1^#(@line, @acc, @m))] [computeLine#1^#(::(@x, @xs), @acc, @m)] = [1] @m + [0] >= [1] @m + [0] = [c_2(computeLine#2^#(@m, @acc, @x, @xs))] [computeLine#2^#(::(@l, @ls), @acc, @x, @xs)] = [1] @l + [1] @ls + [1] > [1] @ls + [0] = [c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc)))] Consider the set of all dependency pairs DPs: { 1: computeLine^#(@line, @m, @acc) -> c_1(computeLine#1^#(@line, @acc, @m)) , 2: computeLine#1^#(::(@x, @xs), @acc, @m) -> c_2(computeLine#2^#(@m, @acc, @x, @xs)) , 3: bftMult'^#(@queue, @acc) -> c_4(bftMult'#1^#(bftMult'#2(@queue), @acc)) , 4: bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_5(bftMult'#3^#(@elem, @acc, @queue)) , 5: bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_6(bftMult'#4^#(@t, @acc, @queue)) , 6: bftMult'#4^#(leaf(), @acc, @queue) -> c_7(bftMult'^#(@queue, @acc)) , 7: bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_8(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , 8: bftMult'#5^#(@queue', @acc, @y) -> c_9(bftMult'^#(@queue', matrixMult(@acc, @y))) , 9: bftMult'#5^#(@queue', @acc, @y) -> c_10(matrixMult^#(@acc, @y)) , 10: matrixMult^#(@m1, @m2) -> c_11(matrixMult#1^#(@m1, @m2)) , 11: matrixMult#1^#(::(@l, @ls), @m2) -> c_12(matrixMult^#(@ls, @m2)) , 12: matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil())) , 13: computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc))) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {12,13}. These cover all (indirect) predecessors of dependency pairs {1,2,12,13}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { bftMult'^#(@queue, @acc) -> c_4(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_5(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_6(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_7(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_8(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_9(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_10(matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_11(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_12(matrixMult^#(@ls, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil())) , computeLine^#(@line, @m, @acc) -> c_1(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_2(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc))) } Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bftMult'^#(@queue, @acc) -> c_4(bftMult'#1^#(bftMult'#2(@queue), @acc)) , bftMult'#1^#(tuple#2(@elem, @queue), @acc) -> c_5(bftMult'#3^#(@elem, @acc, @queue)) , bftMult'#3^#(::(@t, @_@3), @acc, @queue) -> c_6(bftMult'#4^#(@t, @acc, @queue)) , bftMult'#4^#(leaf(), @acc, @queue) -> c_7(bftMult'^#(@queue, @acc)) , bftMult'#4^#(node(@y, @t1, @t2), @acc, @queue) -> c_8(bftMult'#5^#(enqueue(@t2, enqueue(@t1, @queue)), @acc, @y)) , bftMult'#5^#(@queue', @acc, @y) -> c_9(bftMult'^#(@queue', matrixMult(@acc, @y))) , bftMult'#5^#(@queue', @acc, @y) -> c_10(matrixMult^#(@acc, @y)) , matrixMult^#(@m1, @m2) -> c_11(matrixMult#1^#(@m1, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_12(matrixMult^#(@ls, @m2)) , matrixMult#1^#(::(@l, @ls), @m2) -> c_13(computeLine^#(@l, @m2, nil())) , computeLine^#(@line, @m, @acc) -> c_1(computeLine#1^#(@line, @acc, @m)) , computeLine#1^#(::(@x, @xs), @acc, @m) -> c_2(computeLine#2^#(@m, @acc, @x, @xs)) , computeLine#2^#(::(@l, @ls), @acc, @x, @xs) -> c_3(computeLine^#(@xs, @ls, lineMult(@x, @l, @acc))) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bftMult'#2(tuple#2(@dequeue@1, @dequeue@2)) -> dequeue(@dequeue@1, @dequeue@2) , dequeue(@outq, @inq) -> dequeue#1(@outq, @inq) , enqueue(@t, @queue) -> enqueue#1(@queue, @t) , matrixMult(@m1, @m2) -> matrixMult#1(@m1, @m2) , computeLine(@line, @m, @acc) -> computeLine#1(@line, @acc, @m) , computeLine#1(::(@x, @xs), @acc, @m) -> computeLine#2(@m, @acc, @x, @xs) , computeLine#1(nil(), @acc, @m) -> @acc , computeLine#2(::(@l, @ls), @acc, @x, @xs) -> computeLine(@xs, @ls, lineMult(@x, @l, @acc)) , computeLine#2(nil(), @acc, @x, @xs) -> nil() , lineMult(@n, @l1, @l2) -> lineMult#1(@l1, @l2, @n) , dequeue#1(::(@t, @ts), @inq) -> tuple#2(::(@t, nil()), tuple#2(@ts, @inq)) , dequeue#1(nil(), @inq) -> dequeue#2(reverse(@inq)) , reverse(@xs) -> appendreverse(@xs, nil()) , dequeue#2(::(@t, @ts)) -> tuple#2(::(@t, nil()), tuple#2(@ts, nil())) , dequeue#2(nil()) -> tuple#2(nil(), tuple#2(nil(), nil())) , enqueue#1(tuple#2(@outq, @inq), @t) -> tuple#2(@outq, ::(@t, @inq)) , lineMult#1(::(@x, @xs), @l2, @n) -> lineMult#2(@l2, @n, @x, @xs) , lineMult#1(nil(), @l2, @n) -> nil() , lineMult#2(::(@y, @ys), @n, @x, @xs) -> ::(+(*(@x, @n), @y), lineMult(@n, @xs, @ys)) , lineMult#2(nil(), @n, @x, @xs) -> ::(*(@x, @n), lineMult(@n, @xs, nil())) , matrixMult#1(::(@l, @ls), @m2) -> ::(computeLine(@l, @m2, nil()), matrixMult(@ls, @m2)) , matrixMult#1(nil(), @m2) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded Wall-time: 2.117876s CPU-time: 13.766s Wall-time: 1.688144s CPU-time: 10.628s Wall-time: 54.623683s CPU-time: 473.389s Hurray, we answered YES(O(1),O(n^3))